package com.warom.sdg.service;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;

import com.warom.sdg.model.PestDetectionEntity;
import com.warom.sdg.model.PlcDeviceEntity;
import com.warom.sdg.repository.PlcDeviceRepository;
import com.warom.sdg.repository.PestDetectionRepository;
import com.warom.sdg.util.GranaryDeviceManager;
import com.warom.sdg.util.LogUtils;
import com.warom.sdg.util.OpenApiClient;
import com.warom.sdg.util.OpenApiExample;
import com.warom.sdg.util.PestDetectionHelper;

import java.io.File;
import java.io.FileOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 虫情检测服务
 * 负责定时获取设备图像，检测害虫，并保存检测结果
 */
public class PestDetectionService extends Service {
    private static final String TAG = "PestDetectionService";

    // 唤醒和截图之间的延迟（毫秒）
    private static final long WAKEUP_SCREENSHOT_DELAY = 5000;
    
    // 默认轮询间隔（毫秒）- 默认30分钟
    private static final long DEFAULT_POLL_INTERVAL = 30 * 60 * 1000;
    
    // 设备轮询器
    private ScheduledExecutorService scheduler;
    
    // 主线程Handler，用于回调
    private Handler mainHandler;
    
    // 虫情检测数据仓库
    private PestDetectionRepository pestDetectionRepository;
    
    // 设备数据仓库
    private PlcDeviceRepository deviceRepository;
    
    // 服务运行状态
    private boolean isRunning = false;
    
    // 当前正在捕获图像标记
    private AtomicBoolean isCapturing = new AtomicBoolean(false);
    
    // 轮询间隔
    private long pollInterval = DEFAULT_POLL_INTERVAL;
    
    // 固定设备信息
    private static final String DEVICE_ID = "3a131a889160de64ptx9";
    private AtomicInteger currentChannel = new AtomicInteger(0); // 当前选择通道，原子操作确保线程安全
    private static final int MAX_CHANNELS = 5; // 设备有5个通道 (0-4)
    private static final String APP_KEY = "K35Y9D4F6H1B7V2M8";
    private static final String APP_SECRET = "5H2D8G4F7J1M6K3L9N5P2Q7R4S8V";
    
    // 服务绑定器
    private final IBinder binder = new PestDetectionServiceBinder();
    
    /**
     * 虫情检测服务绑定器
     */
    public class PestDetectionServiceBinder extends Binder {
        public PestDetectionService getService() {
            return PestDetectionService.this;
        }
    }
    
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "虫情检测服务创建");
        
        // 初始化仓库
        pestDetectionRepository = new PestDetectionRepository(this);
        deviceRepository = new PlcDeviceRepository(this);
        
        // 初始化主线程Handler
        mainHandler = new Handler(Looper.getMainLooper());
        
        // 创建定时任务执行器
        scheduler = Executors.newScheduledThreadPool(1);
        
        // 初始化智慧粮仓设备管理器，使用固定的APP_KEY和APP_SECRET
        GranaryDeviceManager deviceManager = GranaryDeviceManager.getInstance(this);
        deviceManager.init(APP_KEY, APP_SECRET);
    }
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "虫情检测服务启动");
        
        // 如果服务已经在运行，直接返回
        if (isRunning) {
            return START_STICKY;
        }
        
        // 启动服务
        startService();
        
        // 如果服务被杀死，系统会尝试重新创建服务
        return START_STICKY;
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "虫情检测服务绑定");
        return binder;
    }
    
    @Override
    public void onDestroy() {
        Log.d(TAG, "虫情检测服务销毁");
        
        // 停止服务
        stopService();
        
        super.onDestroy();
    }
    
    /**
     * 启动服务
     */
    public void startService() {
        if (isRunning) {
            return;
        }
        
        Log.d(TAG, "启动虫情检测服务");
        
        // 更新运行状态
        isRunning = true;
        
        // 启动定时任务
        startScheduler();
    }
    
    /**
     * 停止服务
     */
    public void stopService() {
        if (!isRunning) {
            return;
        }
        
        Log.d(TAG, "停止虫情检测服务");
        
        // 更新运行状态
        isRunning = false;
        
        // 停止定时任务
        stopScheduler();
    }
    
    /**
     * 启动定时任务
     */
    private void startScheduler() {
        // 先停止已有的定时任务
        stopScheduler();
        
        // 创建新的定时任务
        scheduler = Executors.newScheduledThreadPool(1);
        
        // 开始定时任务，定期从所有设备采集图像
        scheduler.scheduleAtFixedRate(this::captureImagesFromAllDevices, 0, pollInterval, TimeUnit.MILLISECONDS);
        
        Log.d(TAG, "启动定时虫情检测任务，间隔: " + pollInterval + "ms");
    }
    
    /**
     * 停止定时任务
     */
    private void stopScheduler() {
        if (scheduler != null && !scheduler.isShutdown()) {
            scheduler.shutdown();
            try {
                // 等待任务结束
                if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                    scheduler.shutdownNow();
                }
            } catch (InterruptedException e) {
                scheduler.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
    
    /**
     * 从设备采集图像，使用固定设备ID并轮询通道
     */
    private void captureImagesFromAllDevices() {
        // 如果当前正在捕获，则跳过本次任务
        if (isCapturing.get()) {
            Log.d(TAG, "上一次捕获任务尚未完成，跳过本次任务");
            return;
        }
        
        isCapturing.set(true);
        
        try {
            // 获取当前通道号，并准备下一次使用下一个通道
            int channel = currentChannel.getAndUpdate(current -> (current + 1) % MAX_CHANNELS);
            
            Log.d(TAG, "开始采集虫情图像，设备ID: " + DEVICE_ID + ", 通道: " + channel);
            
            // 使用固定设备ID和轮询的通道号
            getLiveStreamAndCapture(DEVICE_ID, channel, (success) -> {
                isCapturing.set(false);
                Log.d(TAG, "虫情图像采集完成，设备ID: " + DEVICE_ID + 
                        ", 通道: " + channel + ", 成功: " + success + 
                        ", 下一次将使用通道: " + currentChannel.get());
            });
        } catch (Exception e) {
            Log.e(TAG, "设备图像采集异常", e);
            LogUtils.logError("虫情检测", "设备图像采集异常", e);
            isCapturing.set(false);
        }
    }
    /**
     * 获取设备直播流并在适当延迟后抓拍图像
     * @param deviceId 设备ID
     * @param channel 通道号
     * @param callback 处理完成回调
     */
    private void getLiveStreamAndCapture(String deviceId, int channel, CaptureCallback callback) {
        try {
            Log.d(TAG, "开始获取设备直播流: " + deviceId + ", 通道: " + channel);
            LogUtils.logOperation("虫情检测", "激活画面", "设备ID: " + deviceId + ", 通道: " + channel);
            
            // 首先唤醒设备
            GranaryDeviceManager deviceManager = GranaryDeviceManager.getInstance(this);
            
            deviceManager.wakeupDevice(deviceId, channel, new GranaryDeviceManager.WakeupCallback() {
                @Override
                public void onSuccess() {
                    Log.d(TAG, "设备唤醒成功: " + deviceId);
                    LogUtils.logOperation("虫情检测", "唤醒设备", "成功, 设备ID: " + deviceId);
                    
                    // 获取直播流来激活画面
                    deviceManager.getLiveStreamUrl(deviceId, channel, true, 1, new GranaryDeviceManager.LiveStreamCallback() {
                        @Override
                        public void onSuccess(String liveStreamUrl) {
                            Log.d(TAG, "获取直播流成功: " + deviceId);
                            LogUtils.logOperation("虫情检测", "获取直播流", "成功, 设备ID: " + deviceId);
                            
                            // 等待几秒后进行截图
                            mainHandler.postDelayed(() -> {
                                captureScreenshot(deviceId, channel, callback);
                            }, WAKEUP_SCREENSHOT_DELAY);
                        }
                        
                        @Override
                        public void onFailure(Exception e) {
                            Log.e(TAG, "获取直播流失败: " + deviceId, e);
                            LogUtils.logError("虫情检测", "获取直播流失败, 设备ID: " + deviceId, e);
                            callback.onComplete(false);
                        }
                    });
                }
                
                @Override
                public void onFailure(Exception e) {
                    Log.e(TAG, "设备唤醒失败: " + deviceId, e);
                    LogUtils.logError("虫情检测", "唤醒设备失败, 设备ID: " + deviceId, e);
                    callback.onComplete(false);
                }
            });
        } catch (Exception e) {
            Log.e(TAG, "获取直播流过程异常: " + deviceId, e);
            LogUtils.logError("虫情检测", "获取直播流过程异常, 设备ID: " + deviceId, e);
            callback.onComplete(false);
        }
    }
    
    /**
     * 抓拍设备截图
     * @param deviceId 设备ID
     * @param channel 通道号
     * @param callback 处理完成回调
     */
    private void captureScreenshot(String deviceId, int channel, CaptureCallback callback) {
        try {
            Log.d(TAG, "开始抓拍设备截图: " + deviceId + ", 通道: " + channel);
            LogUtils.logOperation("虫情检测", "抓拍截图", "设备ID: " + deviceId + ", 通道: " + channel);
            
            GranaryDeviceManager deviceManager = GranaryDeviceManager.getInstance(this);
            
            // 调用获取设备截图API，启用害虫识别
            deviceManager.getDeviceScreenshot(deviceId, channel, true, new GranaryDeviceManager.ScreenshotCallback() {
                @Override
                public void onSuccess(Bitmap originalImage, Bitmap annotatedImage, List<PestDetectionHelper.PestDetectionResult> pestResults) {
                    Log.d(TAG, "获取设备截图成功: " + deviceId);
                    
                    // 保存图像到本地
                    String imagePath = saveImageToLocal(annotatedImage, deviceId);
                    
                    // 保存检测结果到数据库
                    savePestDetectionResults(deviceId, channel, pestResults, imagePath);
                    
                    callback.onComplete(true);
                }
                
                @Override
                public void onFailure(Exception e) {
                    Log.e(TAG, "获取设备截图失败: " + deviceId, e);
                    LogUtils.logError("虫情检测", "获取设备截图失败, 设备ID: " + deviceId, e);
                    callback.onComplete(false);
                }
            });
        } catch (Exception e) {
            Log.e(TAG, "抓拍设备截图过程异常: " + deviceId, e);
            LogUtils.logError("虫情检测", "抓拍设备截图过程异常, 设备ID: " + deviceId, e);
            callback.onComplete(false);
        }
    }
    
    /**
     * 保存图像到本地存储
     * @param bitmap 位图
     * @param deviceId 设备ID
     * @return 保存的文件路径
     */
    private String saveImageToLocal(Bitmap bitmap, String deviceId) {
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
        String fileName = "pest_detection_" + deviceId + "_" + timeStamp + ".jpg";
        
        try {
            // 获取应用私有目录
            File directory = new File(getExternalFilesDir(null), "pest_images");
            if (!directory.exists()) {
                directory.mkdirs();
            }
            
            File file = new File(directory, fileName);
            FileOutputStream fos = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);
            fos.flush();
            fos.close();
            
            Log.d(TAG, "截图已保存: " + file.getAbsolutePath());
            return file.getAbsolutePath();
        } catch (Exception e) {
            Log.e(TAG, "保存截图失败", e);
            LogUtils.logError("虫情检测", "保存截图失败", e);
            return null;
        }
    }
    
    /**
     * 保存害虫检测结果到数据库
     * @param deviceId 设备ID
     * @param channel 通道号
     * @param pestResults 害虫检测结果
     * @param imagePath 图像保存路径
     */
    private void savePestDetectionResults(String deviceId, int channel, List<PestDetectionHelper.PestDetectionResult> pestResults, String imagePath) {
        if (pestResults == null || pestResults.isEmpty()) {
            Log.d(TAG, "未检测到害虫，不保存数据");
            return;
        }
        
        Log.d(TAG, "检测到 " + pestResults.size() + " 个害虫，保存到数据库");
        
        for (PestDetectionHelper.PestDetectionResult result : pestResults) {
            // 创建数据实体
            PestDetectionEntity entity = new PestDetectionEntity();
            // 使用通道号标识不同设备，因为我们只有一个固定设备ID
            entity.setDeviceId(channel); 
            entity.setPestType(result.pestTypeName);
            entity.setConfidence(result.confidence);
            entity.setCount(1); // 每个检测结果算一个
            entity.setImageUrl(imagePath);
            entity.setTimestamp(System.currentTimeMillis());
            
            // 根据置信度确定状态
            if (result.confidence > 0.8) {
                entity.setStatus("危险");
            } else if (result.confidence > 0.5) {
                entity.setStatus("警告");
            } else {
                entity.setStatus("正常");
            }
            
            // 保存到数据库
            pestDetectionRepository.insert(entity,
                    // 成功回调
                    () -> Log.d(TAG, "害虫检测数据保存成功 - 设备ID: " + DEVICE_ID + ", 通道: " + channel),
                    // 失败回调
                    error -> Log.e(TAG, "害虫检测数据保存失败: " + error));
        }
    }
    
    /**
     * 设置轮询间隔
     * @param interval 间隔时间（毫秒）
     */
    public void setPollInterval(long interval) {
        if (interval > 0) {
            this.pollInterval = interval;
            if (isRunning) {
                // 重新启动定时任务以应用新的间隔
                startScheduler();
            }
        }
    }
    
    /**
     * 立即执行一次采集
     */
    public void runCaptureNow() {
        if (!isCapturing.get()) {
            Log.d(TAG, "手动触发虫情图像采集");
            captureImagesFromAllDevices();
        } else {
            Log.d(TAG, "正在采集中，忽略手动触发");
        }
    }
    
    /**
     * 抓拍完成回调接口
     */
    private interface CaptureCallback {
        void onComplete(boolean success);
    }
} 